home *** CD-ROM | disk | FTP | other *** search
/ PC World Komputer 2010 April / PCWorld0410.iso / hity wydania / Ubuntu 9.10 PL / karmelkowy-koliberek-desktop-9.10-i386-PL.iso / casper / filesystem.squashfs / usr / share / hplip / fax / fax.pyc (.txt) < prev    next >
Python Compiled Bytecode  |  2009-10-28  |  24KB  |  729 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.6)
  3.  
  4. from __future__ import generators
  5. import sys
  6. import os
  7. import threading
  8. import cPickle
  9. import time
  10. from cStringIO import StringIO
  11. import struct
  12. from base.g import *
  13. from base.codes import *
  14. from base.ldif import LDIFParser
  15. from base import device, utils, vcard
  16. from prnt import cups
  17.  
  18. try:
  19.     import coverpages
  20. except ImportError:
  21.     pass
  22.  
  23.  
  24. try:
  25.     import dbus
  26. except ImportError:
  27.     log.error('dbus is required for PC send fax.')
  28.  
  29. import warnings
  30. warnings.simplefilter('ignore', DeprecationWarning)
  31. STATUS_IDLE = 0
  32. STATUS_PROCESSING_FILES = 1
  33. STATUS_SENDING_TO_RECIPIENT = 2
  34. STATUS_DIALING = 3
  35. STATUS_CONNECTING = 4
  36. STATUS_SENDING = 5
  37. STATUS_COMPLETED = 6
  38. STATUS_CREATING_COVER_PAGE = 7
  39. STATUS_ERROR = 8
  40. STATUS_BUSY = 9
  41. STATUS_CLEANUP = 10
  42. EVENT_FAX_SEND_CANCELED = 1
  43. RESOLUTION_STD = 1
  44. RESOLUTION_FINE = 2
  45. RESOLUTION_300DPI = 3
  46. FILE_HEADER_SIZE = 28
  47. PAGE_HEADER_SIZE = 24
  48.  
  49. class FaxLDIFParser(LDIFParser):
  50.     
  51.     def __init__(self, input, db):
  52.         LDIFParser.__init__(self, input)
  53.         self.db = db
  54.  
  55.     
  56.     def handle(self, dn, entry):
  57.         pass
  58.  
  59.  
  60.  
  61. class FaxAddressBook(object):
  62.     
  63.     def __init__(self):
  64.         self._data = { }
  65.         self.load()
  66.  
  67.     
  68.     def load(self):
  69.         self._fab = os.path.join(prop.user_dir, 'fab.pickle')
  70.         if os.path.exists(self._fab):
  71.             pickle_file = open(self._fab, 'r')
  72.             self._data = cPickle.load(pickle_file)
  73.             pickle_file.close()
  74.         else:
  75.             self.save()
  76.  
  77.     
  78.     def set(self, name, title, firstname, lastname, fax, groups, notes):
  79.         
  80.         try:
  81.             grps = [ unicode(s) for s in groups ]
  82.         except UnicodeDecodeError:
  83.             grps = [ unicode(s.decode('utf-8')) for s in groups ]
  84.         except:
  85.             []
  86.  
  87.         self._data[unicode(name)] = {
  88.             'name': unicode(name),
  89.             'title': unicode(title),
  90.             'firstname': unicode(firstname),
  91.             'lastname': unicode(lastname),
  92.             'fax': unicode(fax),
  93.             'notes': unicode(notes),
  94.             'groups': grps }
  95.         self.save()
  96.  
  97.     insert = set
  98.     
  99.     def set_key_value(self, name, key, value):
  100.         self._data[unicode(name)][key] = value
  101.         self.save()
  102.  
  103.     
  104.     def get(self, name):
  105.         return self._data.get(name, None)
  106.  
  107.     select = get
  108.     
  109.     def rename(self, old_name, new_name):
  110.         
  111.         try:
  112.             self._data[old_name]
  113.         except KeyError:
  114.             return None
  115.  
  116.         
  117.         try:
  118.             self._data[new_name]
  119.         except KeyError:
  120.             self._data[new_name] = self._data[old_name].copy()
  121.             self._data[new_name]['name'] = new_name
  122.             del self._data[old_name]
  123.             self.save()
  124.  
  125.  
  126.     
  127.     def get_all_groups(self):
  128.         all_groups = []
  129.         for e, v in self._data.items():
  130.             for g in v['groups']:
  131.                 if g not in all_groups:
  132.                     all_groups.append(g)
  133.                     continue
  134.             
  135.         
  136.         return all_groups
  137.  
  138.     
  139.     def get_all_records(self):
  140.         return self._data
  141.  
  142.     
  143.     def get_all_names(self):
  144.         return self._data.keys()
  145.  
  146.     
  147.     def save(self):
  148.         
  149.         try:
  150.             pickle_file = open(self._fab, 'w')
  151.             cPickle.dump(self._data, pickle_file, cPickle.HIGHEST_PROTOCOL)
  152.             pickle_file.close()
  153.         except IOError:
  154.             log.error('I/O error saving fab file.')
  155.  
  156.  
  157.     
  158.     def clear(self):
  159.         self._data = { }
  160.         self.save()
  161.  
  162.     
  163.     def delete(self, name):
  164.         if name in self._data:
  165.             del self._data[name]
  166.             self.save()
  167.             return True
  168.         return False
  169.  
  170.     
  171.     def last_modification_time(self):
  172.         
  173.         try:
  174.             return os.stat(self._fab).st_mtime
  175.         except OSError:
  176.             return 0
  177.  
  178.  
  179.     
  180.     def update_groups(self, group, members):
  181.         for e, v in self._data.items():
  182.             if v['name'] in members:
  183.                 if group not in v['groups']:
  184.                     v['groups'].append(unicode(group))
  185.                 
  186.             group not in v['groups']
  187.             if group in v['groups']:
  188.                 v['groups'].remove(unicode(group))
  189.                 continue
  190.         
  191.         self.save()
  192.  
  193.     
  194.     def delete_group(self, group):
  195.         for e, v in self._data.items():
  196.             if group in v['groups']:
  197.                 v['groups'].remove(unicode(group))
  198.                 continue
  199.         
  200.         self.save()
  201.  
  202.     
  203.     def group_members(self, group):
  204.         members = []
  205.         for e, v in self._data.items():
  206.             if group in v['groups']:
  207.                 members.append(e)
  208.                 continue
  209.         
  210.         return members
  211.  
  212.     
  213.     def add_to_group(self, group, members):
  214.         group_members = self.group_members(group)
  215.         new_group_members = []
  216.         for m in members:
  217.             if m not in group_members:
  218.                 new_group_members.append(m)
  219.                 continue
  220.         
  221.         self.update_groups(group, group_members + new_group_members)
  222.  
  223.     
  224.     def remove_from_group(self, group, remove_members):
  225.         group_members = self.group_members(group)
  226.         new_group_members = []
  227.         for m in group_members:
  228.             if m not in remove_members:
  229.                 new_group_members.append(m)
  230.                 continue
  231.         
  232.         self.update_groups(group, new_group_members)
  233.  
  234.     
  235.     def rename_group(self, old_group, new_group):
  236.         members = self.group_members(old_group)
  237.         self.update_groups(old_group, [])
  238.         self.update_groups(new_group, members)
  239.  
  240.     
  241.     def import_ldif(self, filename):
  242.         
  243.         try:
  244.             data = open(filename, 'r').read()
  245.             log.debug_block(filename, data)
  246.             parser = FaxLDIFParser(open(filename, 'r'), self)
  247.             parser.parse()
  248.             self.save()
  249.             return (True, '')
  250.         except ValueError:
  251.             e = None
  252.             return (False, e.message)
  253.  
  254.  
  255.     
  256.     def import_vcard(self, filename):
  257.         data = file(filename, 'r').read()
  258.         log.debug_block(filename, data)
  259.         for card in vcard.VCards(vcard.VFile(vcard.opentextfile(filename))):
  260.             log.debug(card)
  261.             if card['name']:
  262.                 fax = ''
  263.                 for x in range(1, 9999):
  264.                     if x == 1:
  265.                         s = 'phone'
  266.                     else:
  267.                         s = 'phone%d' % x
  268.                     
  269.                     try:
  270.                         card[s]
  271.                     except KeyError:
  272.                         break
  273.                         continue
  274.  
  275.                     if 'fax' in card[s]['type']:
  276.                         fax = card[s]['number']
  277.                         break
  278.                         continue
  279.                 
  280.                 org = card.get('organisation', '')
  281.                 if org:
  282.                     org = [
  283.                         org]
  284.                 else:
  285.                     org = card.get('categories', '').split(';')
  286.                     if not org:
  287.                         org = []
  288.                     
  289.                 org.append(u'All')
  290.                 groups = _[1]
  291.                 name = card['name']
  292.                 notes = card.get('notes', u'')
  293.                 log.debug('Import: name=%s, fax=%s group(s)=%s notes=%s' % (name, fax, ','.join(groups), notes))
  294.                 self.set(name, u'', u'', u'', fax, groups, notes)
  295.                 continue
  296.             []
  297.         
  298.         return (True, '')
  299.  
  300.  
  301.  
  302. class FaxDevice(device.Device):
  303.     
  304.     def __init__(self, device_uri = None, printer_name = None, callback = None, fax_type = FAX_TYPE_NONE, disable_dbus = False):
  305.         device.Device.__init__(self, device_uri, printer_name, None, callback, disable_dbus)
  306.         self.send_fax_thread = None
  307.         self.upload_log_thread = None
  308.         self.fax_type = fax_type
  309.         if not disable_dbus:
  310.             session_bus = dbus.SessionBus()
  311.             self.service = session_bus.get_object('com.hplip.StatusService', '/com/hplip/StatusService')
  312.         else:
  313.             self.service = None
  314.  
  315.     
  316.     def setPhoneNum(self, num):
  317.         raise AttributeError
  318.  
  319.     
  320.     def getPhoneNum(self):
  321.         raise AttributeError
  322.  
  323.     phone_num = property(getPhoneNum, setPhoneNum)
  324.     
  325.     def setStationName(self, name):
  326.         raise AttributeError
  327.  
  328.     
  329.     def getStationName(self):
  330.         raise AttributeError
  331.  
  332.     station_name = property(getStationName, setStationName)
  333.     
  334.     def setDateAndTime(self):
  335.         raise AttributeError
  336.  
  337.     
  338.     def uploadLog(self):
  339.         raise AttributeError
  340.  
  341.     
  342.     def isUploadLogActive(self):
  343.         raise AttributeError
  344.  
  345.     
  346.     def waitForUploadLogThread(self):
  347.         raise AttributeError
  348.  
  349.     
  350.     def sendFaxes(self, phone_num_list, fax_file_list, cover_message = '', cover_re = '', cover_func = None, preserve_formatting = False, printer_name = '', update_queue = None, event_queue = None):
  351.         raise AttributeError
  352.  
  353.     
  354.     def isSendFaxActive(self):
  355.         if self.send_fax_thread is not None:
  356.             return self.send_fax_thread.isAlive()
  357.         return False
  358.  
  359.     
  360.     def waitForSendFaxThread(self):
  361.         if self.send_fax_thread is not None and self.send_fax_thread.isAlive():
  362.             
  363.             try:
  364.                 self.send_fax_thread.join()
  365.             except KeyboardInterrupt:
  366.                 pass
  367.             except:
  368.                 None<EXCEPTION MATCH>KeyboardInterrupt
  369.             
  370.  
  371.         None<EXCEPTION MATCH>KeyboardInterrupt
  372.  
  373.  
  374.  
  375. def getFaxDevice(device_uri = None, printer_name = None, callback = None, fax_type = FAX_TYPE_NONE, disable_dbus = False):
  376.     if fax_type == FAX_TYPE_NONE:
  377.         if device_uri is None and printer_name is not None:
  378.             printers = cups.getPrinters()
  379.             for p in printers:
  380.                 if p.name.lower() == printer_name.lower():
  381.                     device_uri = p.device_uri
  382.                     break
  383.                     continue
  384.             else:
  385.                 raise Error(ERROR_DEVICE_NOT_FOUND)
  386.         if device_uri is not None:
  387.             mq = device.queryModelByURI(device_uri)
  388.             fax_type = mq['fax-type']
  389.         
  390.     
  391.     log.debug('fax-type=%d' % fax_type)
  392.     if fax_type in (FAX_TYPE_BLACK_SEND_EARLY_OPEN, FAX_TYPE_BLACK_SEND_LATE_OPEN):
  393.         PMLFaxDevice = PMLFaxDevice
  394.         import pmlfax
  395.         return PMLFaxDevice(device_uri, printer_name, callback, fax_type, disable_dbus)
  396.     if fax_type == FAX_TYPE_SOAP:
  397.         SOAPFaxDevice = SOAPFaxDevice
  398.         import soapfax
  399.         return SOAPFaxDevice(device_uri, printer_name, callback, fax_type, disable_dbus)
  400.     raise Error(ERROR_DEVICE_DOES_NOT_SUPPORT_OPERATION)
  401.  
  402. STATE_DONE = 0
  403. STATE_ABORTED = 10
  404. STATE_SUCCESS = 20
  405. STATE_BUSY = 25
  406. STATE_READ_SENDER_INFO = 30
  407. STATE_PRERENDER = 40
  408. STATE_COUNT_PAGES = 50
  409. STATE_NEXT_RECIPIENT = 60
  410. STATE_COVER_PAGE = 70
  411. STATE_SINGLE_FILE = 80
  412. STATE_MERGE_FILES = 90
  413. STATE_SINGLE_FILE = 100
  414. STATE_SEND_FAX = 110
  415. STATE_CLEANUP = 120
  416. STATE_ERROR = 130
  417.  
  418. class FaxSendThread(threading.Thread):
  419.     
  420.     def __init__(self, dev, service, phone_num_list, fax_file_list, cover_message = '', cover_re = '', cover_func = None, preserve_formatting = False, printer_name = '', update_queue = None, event_queue = None):
  421.         threading.Thread.__init__(self)
  422.         self.dev = dev
  423.         self.service = service
  424.         self.phone_num_list = phone_num_list
  425.         self.fax_file_list = fax_file_list
  426.         self.update_queue = update_queue
  427.         self.event_queue = event_queue
  428.         self.cover_message = cover_message
  429.         self.cover_re = cover_re
  430.         self.cover_func = cover_func
  431.         self.current_printer = printer_name
  432.         self.stream = StringIO()
  433.         self.prev_update = ''
  434.         self.remove_temp_file = False
  435.         self.preserve_formatting = preserve_formatting
  436.         self.results = { }
  437.         self.cover_page_present = False
  438.         self.recipient_file_list = []
  439.         self.f = None
  440.         self.job_hort_dpi = 0
  441.         self.job_hort_dpi = 0
  442.         self.job_vert_dpi = 0
  443.         self.job_page_size = 0
  444.         self.job_resolution = 0
  445.         self.job_encoding = 0
  446.  
  447.     
  448.     def pre_render(self, state):
  449.         self.cover_page_present = False
  450.         log.debug(self.fax_file_list)
  451.         for fax_file in self.fax_file_list:
  452.             (fax_file_name, fax_file_type, fax_file_desc, fax_file_title, fax_file_pages) = fax_file
  453.             if fax_file_type == 'application/hplip-fax-coverpage':
  454.                 self.cover_page_present = True
  455.                 log.debug('Skipping coverpage')
  456.             else:
  457.                 self.rendered_file_list.append((fax_file_name, 'application/hplip-fax', 'HP Fax', fax_file_title))
  458.                 log.debug('Processing pre-rendered file: %s (%d pages)' % (fax_file_name, fax_file_pages))
  459.             if self.check_for_cancel():
  460.                 state = STATE_ABORTED
  461.                 continue
  462.         
  463.         log.debug(self.rendered_file_list)
  464.         if self.check_for_cancel():
  465.             state = STATE_ABORTED
  466.         
  467.         return state
  468.  
  469.     
  470.     def count_pages(self, state):
  471.         self.recipient_file_list = self.rendered_file_list[:]
  472.         log.debug('Counting total pages...')
  473.         self.job_total_pages = 0
  474.         log.debug(self.recipient_file_list)
  475.         i = 0
  476.         for fax_file in self.recipient_file_list:
  477.             fax_file_name = fax_file[0]
  478.             log.debug('Processing file (counting pages): %s...' % fax_file_name)
  479.             if os.path.exists(fax_file_name):
  480.                 self.results[fax_file_name] = ERROR_SUCCESS
  481.                 fax_file_fd = file(fax_file_name, 'r')
  482.                 header = fax_file_fd.read(FILE_HEADER_SIZE)
  483.                 (magic, version, total_pages, hort_dpi, vert_dpi, page_size, resolution, encoding, reserved1, reserved2) = self.decode_fax_header(header)
  484.                 if magic != 'hplip_g3':
  485.                     log.error('Invalid file header. Bad magic.')
  486.                     self.results[fax_file_name] = ERROR_FAX_INVALID_FAX_FILE
  487.                     state = STATE_ERROR
  488.                     continue
  489.                 
  490.                 if not i:
  491.                     (self.job_hort_dpi, self.job_vert_dpi, self.job_page_size, self.job_resolution, self.job_encoding) = (hort_dpi, vert_dpi, page_size, resolution, encoding)
  492.                     i += 1
  493.                 elif self.job_hort_dpi != hort_dpi and self.job_vert_dpi != vert_dpi and self.job_page_size != page_size and self.job_resolution != resolution or self.job_encoding != encoding:
  494.                     log.error('Incompatible options for file: %s' % fax_file_name)
  495.                     self.results[fax_file_name] = ERROR_FAX_INCOMPATIBLE_OPTIONS
  496.                     state = STATE_ERROR
  497.                 
  498.                 log.debug('Magic=%s Ver=%d Pages=%d hDPI=%d vDPI=%d Size=%d Res=%d Enc=%d' % (magic, version, total_pages, hort_dpi, vert_dpi, page_size, resolution, encoding))
  499.                 self.job_total_pages += total_pages
  500.                 fax_file_fd.close()
  501.             else:
  502.                 log.error('Unable to find HP Fax file: %s' % fax_file_name)
  503.                 self.results[fax_file_name] = ERROR_FAX_FILE_NOT_FOUND
  504.                 state = STATE_ERROR
  505.                 break
  506.             if self.check_for_cancel():
  507.                 state = STATE_ABORTED
  508.                 break
  509.                 continue
  510.         
  511.         if self.cover_page_present:
  512.             self.job_total_pages += 1
  513.         
  514.         log.debug('Total fax pages=%d' % self.job_total_pages)
  515.         return state
  516.  
  517.     
  518.     def decode_fax_header(self, header):
  519.         
  520.         try:
  521.             return struct.unpack('>8sBIHHBBBII', header)
  522.         except struct.error:
  523.             return (-1, -1, -1, -1, -1, -1, -1, -1, -1, -1)
  524.  
  525.  
  526.     
  527.     def decode_page_header(self, header):
  528.         
  529.         try:
  530.             return struct.unpack('>IIIIII', header)
  531.         except struct.error:
  532.             return (-1, -1, -1, -1, -1, -1)
  533.  
  534.  
  535.     
  536.     def cover_page(self, recipient):
  537.         if self.job_total_pages > 1:
  538.             state = STATE_MERGE_FILES
  539.         else:
  540.             state = STATE_SINGLE_FILE
  541.         if self.cover_page_present:
  542.             log.debug('Creating cover page for recipient: %s' % recipient['name'])
  543.             (fax_file, canceled) = self.render_cover_page(recipient)
  544.             if canceled:
  545.                 state = STATE_ABORTED
  546.             elif not fax_file:
  547.                 state = STATE_ERROR
  548.             else:
  549.                 self.recipient_file_list.insert(0, (fax_file, 'application/hplip-fax', 'HP Fax', 'Cover Page'))
  550.                 log.debug('Cover page G3 file: %s' % fax_file)
  551.                 self.results[fax_file] = ERROR_SUCCESS
  552.         
  553.         return state
  554.  
  555.     
  556.     def single_file(self, state):
  557.         state = STATE_SEND_FAX
  558.         log.debug('Processing single file...')
  559.         self.f = self.recipient_file_list[0][0]
  560.         
  561.         try:
  562.             f_fd = file(self.f, 'r')
  563.         except IOError:
  564.             log.error('Unable to open fax file: %s' % self.f)
  565.             state = STATE_ERROR
  566.  
  567.         header = f_fd.read(FILE_HEADER_SIZE)
  568.         (magic, version, total_pages, hort_dpi, vert_dpi, page_size, resolution, encoding, reserved1, reserved2) = self.decode_fax_header(header)
  569.         self.results[self.f] = ERROR_SUCCESS
  570.         if magic != 'hplip_g3':
  571.             log.error('Invalid file header. Bad magic.')
  572.             self.results[self.f] = ERROR_FAX_INVALID_FAX_FILE
  573.             state = STATE_ERROR
  574.         
  575.         log.debug('Magic=%s Ver=%d Pages=%d hDPI=%d vDPI=%d Size=%d Res=%d Enc=%d' % (magic, version, total_pages, hort_dpi, vert_dpi, page_size, resolution, encoding))
  576.         f_fd.close()
  577.         return state
  578.  
  579.     
  580.     def merge_files(self, state):
  581.         log.debug('%s State: Merge multiple files' % '********************')
  582.         log.debug(self.recipient_file_list)
  583.         log.debug('Merging g3 files...')
  584.         self.remove_temp_file = True
  585.         if self.job_total_pages:
  586.             (f_fd, self.f) = utils.make_temp_file()
  587.             log.debug('Temp file=%s' % self.f)
  588.             data = struct.pack('>8sBIHHBBBII', 'hplip_g3', 0x1L, self.job_total_pages, self.job_hort_dpi, self.job_vert_dpi, self.job_page_size, self.job_resolution, self.job_encoding, 0x0L, 0x0L)
  589.             os.write(f_fd, data)
  590.             job_page_num = 1
  591.             for fax_file in self.recipient_file_list:
  592.                 fax_file_name = fax_file[0]
  593.                 log.debug('Processing file: %s...' % fax_file_name)
  594.                 if self.results[fax_file_name] == ERROR_SUCCESS:
  595.                     fax_file_fd = file(fax_file_name, 'r')
  596.                     header = fax_file_fd.read(FILE_HEADER_SIZE)
  597.                     (magic, version, total_pages, hort_dpi, vert_dpi, page_size, resolution, encoding, reserved1, reserved2) = self.decode_fax_header(header)
  598.                     if magic != 'hplip_g3':
  599.                         log.error('Invalid file header. Bad magic.')
  600.                         state = STATE_ERROR
  601.                         break
  602.                     
  603.                     log.debug('Magic=%s Ver=%d Pages=%d hDPI=%d vDPI=%d Size=%d Res=%d Enc=%d' % (magic, version, total_pages, hort_dpi, vert_dpi, page_size, resolution, encoding))
  604.                     for p in range(total_pages):
  605.                         header = fax_file_fd.read(PAGE_HEADER_SIZE)
  606.                         (page_num, ppr, rpp, bytes_to_read, thumbnail_bytes, reserved2) = self.decode_page_header(header)
  607.                         if page_num == -1:
  608.                             log.error('Page header error')
  609.                             state - STATE_ERROR
  610.                             break
  611.                         
  612.                         header = struct.pack('>IIIIII', job_page_num, ppr, rpp, bytes_to_read, thumbnail_bytes, 0x0L)
  613.                         os.write(f_fd, header)
  614.                         self.write_queue((STATUS_PROCESSING_FILES, job_page_num, ''))
  615.                         log.debug('Page=%d PPR=%d RPP=%d BPP=%d Thumb=%s' % (page_num, ppr, rpp, bytes_to_read, thumbnail_bytes))
  616.                         os.write(f_fd, fax_file_fd.read(bytes_to_read))
  617.                         job_page_num += 1
  618.                     
  619.                     fax_file_fd.close()
  620.                     if self.check_for_cancel():
  621.                         state = STATE_ABORTED
  622.                         break
  623.                     
  624.                 self.check_for_cancel()
  625.                 log.error('Skipping file: %s' % fax_file_name)
  626.                 continue
  627.             
  628.             os.close(f_fd)
  629.             log.debug('Total pages=%d' % self.job_total_pages)
  630.         
  631.         return state
  632.  
  633.     
  634.     def next_recipient_gen(self):
  635.         for a in self.phone_num_list:
  636.             yield a
  637.         
  638.  
  639.     
  640.     def render_file(self, path, title, mime_type, force_single_page = False):
  641.         all_pages = True
  642.         page_range = ''
  643.         page_set = 0
  644.         nup = 1
  645.         cups.resetOptions()
  646.         if mime_type in ('application/x-cshell', 'application/x-perl', 'application/x-python', 'application/x-shell', 'application/x-sh', 'text/plain'):
  647.             cups.addOption('prettyprint')
  648.         
  649.         if nup > 1:
  650.             cups.addOption('number-up=%d' % nup)
  651.         
  652.         if force_single_page:
  653.             cups.addOption('page-ranges=1')
  654.         
  655.         sent_job_id = cups.printFile(self.current_printer, path, title)
  656.         cups.resetOptions()
  657.         log.debug('Job ID=%d' % sent_job_id)
  658.         job_id = 0
  659.         time.sleep(1)
  660.         fax_file = ''
  661.         complete = False
  662.         end_time = time.time() + 300
  663.         while time.time() < end_time:
  664.             log.debug('Waiting for fax...')
  665.             result = list(self.service.CheckForWaitingFax(self.dev.device_uri, prop.username, sent_job_id))
  666.             fax_file = str(result[7])
  667.             log.debug('Fax file=%s' % fax_file)
  668.             if fax_file:
  669.                 break
  670.             
  671.             if self.check_for_cancel():
  672.                 log.error('Render canceled. Canceling job #%d...' % sent_job_id)
  673.                 cups.cancelJob(sent_job_id)
  674.                 return ('', True)
  675.             time.sleep(1)
  676.             continue
  677.             self.check_for_cancel()
  678.         log.error('Timeout waiting for rendering. Canceling job #%d...' % sent_job_id)
  679.         cups.cancelJob(sent_job_id)
  680.         return ('', False)
  681.         return (fax_file, False)
  682.  
  683.     
  684.     def check_for_cancel(self):
  685.         canceled = False
  686.         while self.event_queue.qsize():
  687.             
  688.             try:
  689.                 event = self.event_queue.get(0)
  690.                 if event[0] == EVENT_FAX_SEND_CANCELED:
  691.                     canceled = True
  692.                     log.debug('Cancel pressed!')
  693.             continue
  694.             except Queue.Empty:
  695.                 break
  696.                 continue
  697.             
  698.  
  699.             None<EXCEPTION MATCH>Queue.Empty
  700.         return canceled
  701.  
  702.     
  703.     def render_cover_page(self, a):
  704.         log.debug('Creating cover page...')
  705.         pdf = self.cover_func(page_size = coverpages.PAGE_SIZE_LETTER, total_pages = self.job_total_pages, recipient_name = a['name'], recipient_phone = '', recipient_fax = a['fax'], sender_name = self.sender_name, sender_phone = user_conf.get('fax', 'voice_phone'), sender_fax = self.sender_fax, sender_email = user_conf.get('fax', 'email_address'), regarding = self.cover_re, message = self.cover_message, preserve_formatting = self.preserve_formatting)
  706.         log.debug('PDF File=%s' % pdf)
  707.         (fax_file, canceled) = self.render_file(pdf, 'Cover Page', 'application/pdf', force_single_page = True)
  708.         
  709.         try:
  710.             os.remove(pdf)
  711.         except IOError:
  712.             pass
  713.  
  714.         return (fax_file, canceled)
  715.  
  716.     
  717.     def write_queue(self, message):
  718.         if self.update_queue is not None and message != self.prev_update:
  719.             self.update_queue.put(message)
  720.             time.sleep(0)
  721.             self.prev_update = message
  722.         
  723.  
  724.     
  725.     def run(self):
  726.         pass
  727.  
  728.  
  729.